/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package baseDatos;

import entidades.TipoEvento;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Facundo
 */
public class TipoEventoDAO {

    private String query;
    private Connection conDB;
    private PreparedStatement pst;

    public TipoEventoDAO(Connection con) {
        this.conDB = con;
    }

    public TipoEventoDAO() {
    }

    /**
     * @return the query
     */
    public String getQuery() {
        return query;
    }

    /**
     * @param query the query to set
     */
    public void setQuery(String query) {
        this.query = query;
    }

    /**
     * @return the conDB
     */
    public Connection getConDB() {
        return conDB;
    }

    /**
     * @param conDB the conDB to set
     */
    public void setConDB(Connection conDB) {
        this.conDB = conDB;
    }

    /**
     * @return the pst
     */
    public PreparedStatement getPst() {
        return pst;
    }

    /**
     * @param pst the pst to set
     */
    public void setPst(PreparedStatement pst) {
        this.pst = pst;
    }

    /*
     * Metodo que devuelve un tipoEvento de acuerdo al codigo del mismo recibido por parametro
     */
    public TipoEvento getTipoEvento(int codigo) {
        TipoEvento tipo = null;
        setQuery("select * from PC_TIPO_EVENTO where codigo_evento=" + codigo);
        tipo = this.devolverTipoEvento(getQuery());
        return tipo;
    }
    /*
     * Metodo que devuelve un tipoEvento de acuerdo al codigo del mismo recibido por parametro
     */

    public TipoEvento getTipoEvento(String nombre) {
        TipoEvento tipo = null;
        setQuery("select * from PC_TIPO_EVENTO where nombre='" + nombre + "'");
        System.out.println("Sentencia que devuelve el tipo de evento: " + this.getQuery());
        tipo = this.devolverTipoEvento(getQuery());
        return tipo;
    }

    /*
     * Metodo que devuelve un tipo de evento de acuerdo a la sentencia recibida por parametro
     */
    private TipoEvento devolverTipoEvento(String sentencia) {
        try {
            TipoEvento tipo = null;
            ResultSet rs = null;
            setQuery(sentencia);
            setPst(getConDB().prepareStatement(getQuery()));
            rs = getPst().executeQuery();
            while (rs.next()) {
                tipo = new TipoEvento();
                tipo.setNombre(rs.getString("nombre"));
                if (rs.getString("descripcion") != null) {
                    tipo.setDescripcion(rs.getString("descripcion"));
                }
            }
            getPst().close();
            rs.close();
            return tipo;
        } catch (SQLException ex) {
            Logger.getLogger(TipoEventoDAO.class.getName()).log(Level.SEVERE, null, ex);
            System.out.println("Excepcion: " + ex.getMessage() + ". Sentencia utilizada: " + this.getQuery());
        }
        return null;
    }

    /*
     * Metodo que devuelve un arrayList de tipo de eventos
     * por parametro..
     */
    public ArrayList getTipoEventos() {
        ArrayList todos = null;
        setQuery("select * from PC_TIPO_EVENTO");
        todos = this.devolverTipoEventos(getQuery());
        return todos;
    }

    /*
     * Metodo que retorna un arrayList de tipo de eventos, de acuerdo a la sentencia
     * recibida como parametro de entrada
     */
    private ArrayList devolverTipoEventos(String sentencia) {
        ArrayList todos = null;
        TipoEvento tipo = null;
        ResultSet rs;
        setQuery(sentencia);
        try {
            todos = new ArrayList();
            setPst(getConDB().prepareStatement(getQuery()));
            rs = getPst().executeQuery();
            while (rs.next()) {
                tipo = new TipoEvento();
                tipo.setNombre(rs.getString("nombre"));
                if (rs.getString("descripcion") != null) {
                    tipo.setDescripcion(rs.getString("descripcion"));
                }
                todos.add(tipo);
            }
            rs.close();
            getPst().close();
        } catch (SQLException ex) {
            Logger.getLogger(TipoEventoDAO.class.getName()).log(Level.SEVERE, null, ex);
        }
        return todos;
    }

    /*
     * Metodo de prueba.Se inserta un tipo de evento!
     */
    public boolean put(TipoEvento tipo) {
        boolean ret = false;
        TipoEvento aux = null;
        try {

            setQuery("insert into PC_TIPO_EVENTO (codigo_evento,nombre,descripcion) "
                    + "values (?,?,?)");

            setPst(getConDB().prepareStatement(getQuery()));
            getPst().setInt(1, 3);
            getPst().setString(2, tipo.getNombre());
            getPst().setString(3, tipo.getDescripcion());

            ret = getPst().execute();

            if (ret) {
                System.out.print("es verdadero");
            } else {
                System.out.print("es falso");
            }
            getPst().close();


        } catch (SQLException ex) {
            Logger.getLogger(TipoEventoDAO.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println("pasa x aca");
        return ret;
    }

    /*
     * Metodo que devuelve el codigo de un tipo de evento registrado en la base. Recibe como parametro
     * un objeto tipoEvento y retorna el codigo.
     */
    public int getCodigoTipoEvento(TipoEvento tipo) {
        if (tipo == null) {
            System.out.println("tipo evento nulo!");
        }
        setQuery("select codigo_evento from PC_TIPO_EVENTO where nombre='" + tipo.getNombre() + "'");
        System.out.println("sentencia de getCodigoTipoEvento: " + this.getQuery());
        int codigo = this.devolverCodigoTipoEvento(getQuery());
        return codigo;

    }

    /*
     * Metodo que devuelve el codigo de un tipoEvento, de acuerdo a la sentencia recibida por parametro
     */
    private int devolverCodigoTipoEvento(String sentencia) {
        int codigo = -1;
        ResultSet rs = null;
        setQuery(sentencia);
        try {
            setPst(getConDB().prepareStatement(getQuery()));
            rs = getPst().executeQuery();
            while (rs.next()) {
                codigo = rs.getInt("codigo_evento");
            }
            getPst().close();
            rs.close();
        } catch (SQLException ex) {
            Logger.getLogger(TipoEventoDAO.class.getName()).log(Level.SEVERE, null, ex);
        }
        return codigo;
    }
}
